home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Diamond Collection / The Diamond Collection (Software Vault)(Digital Impact).ISO / cdr44 / _xygraf.zip / GRAPHICS.TXT < prev    next >
Text File  |  1995-03-03  |  16KB  |  340 lines
  1. █████████████████████████████████████████████████████████████████████████████
  2. ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
  3. ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ KNOW-HOW.GRAPHICS ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
  4. ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
  5. █████████████████████████████████████████████████████████████████████████████
  6.  
  7. This text contain brief description of KNOW_HOW.GRAPHICS 6.0x, the
  8. product in the 6th version of library. It provide the following features:
  9.     a) Using common code for any graphics library. It is realized now for
  10.        BGI and for Windows GDI. It is not difficult to add few lines of
  11.        code to use any other library, if it support basical operations
  12.        (lineto, moveto etc.)
  13.     b) Scrolling, Zooming, mirror reflection of image, rotations and even
  14.        complex rotations of image. Saying "complex rotations" I mean drawing
  15.        of the picture, rotated around x,y to alpha, then (result) around
  16.        x1,y1 to beta and so on. BGI fonts could be rotated too, filled BGI
  17.        fonts are also available (not all BGI font could be filled, of course).
  18. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  19. Additional (and very powerfull) features are available if KNOW-HOW.GRAPHICS
  20. is used together with KNOW-HOW.SLANG. SLANG is BASIC-like language, designed
  21. as CPP class. Its child classes could have additional operators, so
  22. KNOW-HOW.SLANG.GRAPHICS is the BASIC with access to drawing tools of current
  23. product. It provide to user the possibility to load graphical resourses
  24. (DOS or Windows, or other if he add some code) and interprete them in
  25. run-time. There are very many applications of this tool, like run-time
  26. changeable GUI, maketing (without stage of compilation) of BGI, GDI and so on
  27. applications, vector drawing tools (KNOW-HOW.VECTOR is the ready-to-use
  28. product of this type). Together with BASIC math. functions it could also be
  29. used for data plotting, spreadsheets and so on.
  30.  
  31. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  32. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ SERVICE FILES ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  33. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  34.  
  35. ▐▐▐▐▐▐▐ File SIMPLE.H contains some simplifications for often used names.
  36. Complete listing:
  37.  
  38. ▐ #ifndef __SIMPLE_H_
  39. ▐ #define __SIMPLE_H_
  40. ▐
  41. ▐ typedef unsigned char uchar;
  42. ▐ typedef unsigned long ulong;
  43. ▐ typedef int bool;
  44. ▐
  45. ▐ #define TRUE  1
  46. ▐ #define FALSE 0
  47. ▐ #define ON   TRUE
  48. ▐ #define OFF  FALSE
  49. ▐
  50. ▐ #endif __SIMPLE_H_
  51. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  52. -----------------------------------------------------------------------------
  53. ▐▐▐▐▐▐▐ File GEOM.H contains geometry of KNOW-HOW. It defines geom. objects
  54. in C++ manner: loc(x, y) defines point, rect(x1, y1, x2, y2) - rectangle and
  55. so on.
  56. For example, instead of call to f(int x, int y) we could call f(loc l), where
  57. loc is defined in GEOM.H as
  58. ▐ struct loc
  59. ▐ { int X,Y;
  60. ▐ .....
  61. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  62. -----------------------------------------------------------------------------
  63. ▐▐▐▐▐▐▐ Files TRIGON.H and TRIGON.CPP contains structure with the overloaded
  64. sin(int) and cos(int) functions. This functions works much faster than standart
  65. versions but are not so flexible.
  66. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  67. -----------------------------------------------------------------------------
  68. ▐▐▐▐▐▐▐ Files KH_ERROR.H and KH_ERROR.CPP are the part of KNOW-HOW error
  69. handling system. The only variable is defined: kh_error_code. Functions of
  70. KNOW-HOW or user-defined functions could change it, default value is
  71. KH_SUCCESS:
  72.  
  73. ▐ enum { KH_SUCCESS, KH_UNKNOWN_ERROR, KH_FILE_ERROR, KH_BGI_ERROR,
  74. ▐       KH_MEMORY_ERROR, KH_USER_ERROR };
  75.  
  76. This list could be continued:
  77.  
  78. ▐ enum { KH_NEW_ERROR = KH_USER_ERROR + 1, ... }
  79. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  80. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ DRAWING MODULES ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  81. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  82.  
  83. ▐▐▐▐▐▐▐ File ABS_GRAF.H contains empty shablons of functions. We could
  84. derivate classes from it not thinking about concrete graphics library we
  85. shell use. It provide common code for any DOS, Windows and so on libraries,
  86. if them include the same functions. This set is only part of Paint class's
  87. functions set, described in PAINT.H:
  88.  
  89. ▐ struct AbstractGraphics
  90. ▐    {
  91. ▐    virtual void moveto(int x, int y) {}
  92. ▐    virtual void lineto(int x, int y) {}
  93. ▐    virtual void fillpoly(int numpoints, int* polypoints) {}
  94. ▐    };
  95. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  96. -----------------------------------------------------------------------------
  97. ▐▐▐▐▐▐▐ Files BGI_FONT.H and BGI_FONT.CPP contains class, which incapsulate
  98. BGI fonts (*.chr) description.
  99.     1. BGI fonts are not documented. I use existing format.
  100.     2. Abstract (non-BGI) graphics is used for moveto, lineto, drawpoly and
  101.        fillpoly operations. It should be overloaded in child classes for
  102.        concrete graf. libraries like BGI, Windows GDI and so on.
  103.     3. BGI header have some fields, which are not absolutely necessary (for
  104.        current class). I skip them and remarks are not complete for them.
  105. BGI font format is documented in the remarks to code in these files. So I
  106. give here only the brief explanation. BGI use two types of commands for
  107. drawing - moveto and lineto. To define non-filled fonts I use calls to the
  108. same (virtual) functions. To draw filled fonts I use fillpoly() function.
  109. In this case lineto calls are added to points array, and moveto call stop
  110. the polygon creation and begin next one. To use filled fonts you should
  111. use fonts which are drawn as group of closed polygons. Example - 'O' char:
  112.  
  113.        ┌───────┐
  114.        │▓▓▓▓▓▓▓│
  115.        │▓┌───┐▓│
  116.        │▓│   │▓│
  117.        │▓└─┬─┘▓│
  118.        │▓▓▓│▓▓▓│
  119.        └───┴───┘
  120. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  121. -----------------------------------------------------------------------------
  122. ▐▐▐▐▐▐▐ Files PAINT.H and PAINT.CPP. In the files described previously, we
  123. have incapsulated graphics primitives like lineto, moveto, drawchar and
  124. so on. Now the additional shell is included for rotation, mirror reflection,
  125. complex rotation, zooming and scrolling. All this operations are performed
  126. with abstract graphics calls, and not depend on library which you intend
  127. to use.
  128. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  129. ------------------------- WHAT IS COMPLEX ROTATION ? ------------------------
  130. ░Rotation could be simply processed if it is single operation. To use nested
  131. ░rotations we use stack of rotations info structures. Example of complex
  132. ░rotation:
  133. ░
  134. ░     void f1(int x, int y, int alpha) { ... perform rotation ... }
  135. ░     void f2(int x, int y, int alpha) { rotate(10,10,90); f1(x, y, alpha); }
  136. ░Function f2() call rotation procedure and then call f1(), which call another
  137. ░rotation. We could a) cancel first rotation and b) add first and second
  138. ░rotations to complex transformation. KNOW-HOW.GRAPHICS make possible both
  139. ░variances.
  140. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  141. The structure RInfo is used to keep information about single rotation, and
  142. stack of RInfo's is used (if R_STACK variable is set to 1) to keep complex
  143. rotation information.
  144. ▐ struct RInfo
  145. ▐    {
  146. ▐    loc center;
  147. ▐    int angle;
  148. ▐    };
  149. ///////////////
  150. ▐ struct Stack
  151. ▐    {
  152. ▐    int used, total;
  153. ▐    RInfo* list;
  154. ▐
  155. ▐    Stack();
  156. ▐    ~Stack();
  157. ▐    void push(RInfo* r);
  158. ▐    void pop();
  159. ▐    void flash();
  160. ▐    };
  161. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  162. -----------------------------------------------------------------------------
  163. Class Paint give some additional facilities for any graphics library. Class
  164. does not contain calls to the concrete drawing functions - only to abstract
  165. prototypes.
  166. functions shold be overloaded in child classes for adaptation to concrete
  167. graphic interface (BGI, GDI, and so on).
  168.  
  169. The zoom and addzoom are deformation coeficients. You could use zoom in any
  170. part of program. Addzoom is used only once to set the additional deformation
  171. of the whole picture (for example if context is changed from screen to
  172. printer), for preview and so on.
  173.  
  174. ▐ class Paint : public BGI_Font
  175. ▐    {
  176. ▐    protected:
  177. ▐    loc zoom;                     // Image deformation
  178. ▐    loc add_zoom;                 // Additional deformation
  179. ▐    loc lt;                       // Scroll of part of picture
  180. ▐    loc add_scroll;               // Left - top clip of the whole picture
  181. ▐    int fill;                     // Fill flag
  182. ▐    loc center;                   // Rotation center
  183. ▐    int alpha;                    // Rotation angle
  184. ▐    bool R_STACK;                 // Use or not stack of rotations
  185. ▐    Stack* r_stack;               // Stack of rotations
  186. ▐    int mirror;
  187. ▐    public:
  188. ▐    Paint();
  189. ▐    ~Paint() { delete r_stack; }
  190. ▐
  191. ▐    loc get_add_zoom() { return add_zoom; }
  192. ▐    loc get_zoom() { return zoom; }
  193. ▐
  194. ▐    void set_mirror(int m) { mirror = m; } // X coord. if no rotation
  195. ▐    void set_stack(bool r) { R_STACK = r; r_stack->flash();
  196. ▐        rotate(loc(0, 0), 0); }
  197. ▐    void set_zoom(double x, double y) { zoom.X = x * add_zoom.X;
  198. ▐        zoom.Y = y * add_zoom.Y; }    // No out-of-range control !!!
  199. ▐    void set_add_zoom(double x, double y) { add_zoom.X = 100 * x;
  200. ▐        add_zoom.Y = 100 * y; }
  201. ▐    void set_scroll(int x, int y) { lt.X = x; lt.Y = y; }
  202. ▐    void set_add_scroll(int x, int y) { add_scroll.X = x;
  203. ▐        add_scroll.Y = y; }
  204. ▐    void rotate(loc c, int a);
  205. ▐    void set_fill(bool f) { fill = f; }
  206. ▐
  207. ▐ // Using alpha and center returns rotated coordinates
  208. ▐    loc rot(int x, int y);
  209. ▐ // Return completely transformed point: rotated, zoomed and scrolled
  210. ▐    loc transform(int x, int y);
  211. ▐    };
  212. -----------------------------------------------------------------------------
  213. ▐▐▐▐▐▐▐ Files BGIPAINT.H and BGIPAINT.CPP. Classes in these files replace
  214. calls to empty graphics primitives functions to concrete calls of functions
  215. from BGI, GDI or from other drawing libraries. The #define directives set
  216. switches on one of libraries, user should unremark one of them to use it
  217. in program:
  218.  
  219. As the example, lets look to the code for DOS BGI.
  220.  
  221. ▐ #ifdef DOS_BGI           // If we define DOS_BGI 
  222. ▐ #include <graphics.h>    // Include GBI header
  223. The following structure do nonthing but replace calls to f() {} to calls
  224. to f() { ::f(); }, where ::f() is BGI function.
  225. ▐ struct To_Paint
  226. ▐     {
  227. ▐     void putpixel(int x, int y) { ::putpixel(x, y, getcolor()); }
  228. ▐     void line(int xstart, int ystart, int xend, int yend)
  229. ▐     { line(xstart, ystart, xend, yend); }
  230. ▐
  231. ▐     void moveto(int x, int y) { ::moveto(x, y); }
  232. ▐     void lineto(int x, int y) { ::lineto(x, y); }
  233. ▐     void fillpoly(int numpoints, int* polypoints)
  234. ▐     { ::fillpoly(numpoints, polypoints); }
  235. ▐     void circle(int x, int y, int radius) { ::circle(x, y, radius); }
  236. ▐     void ellipse(int x, int y, int stangle, int endangle, int xr, int yr)
  237. ▐     { ::ellipse(x, y, stangle, endangle, xr, yr); }
  238. ▐     void drawpoly(int numpoints, int far* points)
  239. ▐     { ::drawpoly(numpoints, points); }
  240. ▐     };
  241. ▐ #endif DOS_BGI
  242.  
  243. Then we combine Paint class possibilities to zoom, scroll, rotate (including
  244. complex rotations) and so on and To_Paint possibilities to output graphics
  245. primitives using different libraries.
  246.  
  247. ▐ class KH_Paint : public To_Paint, public Paint
  248. ▐     {
  249. ▐     public:
  250. ▐     KH_Paint() : Paint()   {}
  251. ▐
  252. ▐     void putpixel(int x, int y);
  253. ▐     void line(int xstart, int ystart, int xend, int yend);
  254. ▐     void lineto(int x, int y);
  255. ▐     void moveto(int x, int y);
  256. ▐     void circle(int x, int y, int radius);
  257. ▐     void ellipse(int x, int y, int stangle, int endangle, int xr, int yr);
  258. ▐     void roundrect(int left, int top, int right, int bottom, int radius);
  259. ▐
  260. ▐     void rectangle(int left, int top, int right, int bottom);
  261. ▐     void drawpoly(int numpoints, int far* points);
  262. ▐     void outtext(char far* str);
  263. ▐     };
  264.  
  265. «»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«
  266. ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ATTENTION !!! ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
  267.     1. The set of functions of KH_Paint class will be continued, it is
  268. possible that your version contains additional functions (setcolor() is 
  269. already included, both (int color) and (Red, Green, Blue)).
  270.     2. When the Windows compatible part (class To_Paint for Windows) was
  271. designed, I find some difficulties: Windows GDI is more powerfull than DOS
  272. BGI. It is also possible that when user will try to use his graphics library
  273. he find that it have some functions which are absent in both BGI and GDI.
  274. The solution is: use KH_Paint functions if possible, I think that it is much
  275. more than enought for most cases. Another way is to add new functions to
  276. KH_Paint (KH_Paint::draw_pig() {...} and so on, and modify To_Paint for DOS
  277. and Windows), If it is not possible - use direct calls to your lovely library
  278. - and forget about the compatibility with others.
  279.     3. KH_Paint above is restricted. The real listing of 6.0 version (and of
  280. course of 6.x) is Windows GDI - oriented. It means that if BGI does not
  281. contain some of GDI features, DOS BGI version of To_Paint class try to
  282. elulate them.
  283. ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
  284. «»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«
  285. -----------------------------------------------------------------------------
  286. Example.
  287. I add to *.CPP files (when possible) working examples of main() functions,
  288. to run it you need only to remove remarks. In this file I illustrate only
  289. the usage of KNOW-HOW.GRAPHICS with DOS BGI, but BGIPAINT file contains
  290. also example of Windows OWL usage.
  291.  
  292. ▐ void main()
  293. ▐     {
  294. ▐     int gdriver = DETECT, gmode;           // Standart BGI initialization
  295. ▐     initgraph(&gdriver, &gmode, "");       // see Borland help system
  296. ▐
  297. ▐     KH_Paint* paint = new KH_Paint();      // Create new KH_Paint class
  298. ▐     paint->load("euro.chr");               // Load BGI font
  299. ▐     setcolor(LIGHTRED);
  300. ▐     setfillstyle(SOLID_FILL, LIGHTGRAY);
  301. ▐     paint->set_fill(ON);                   // This flag acts on drawpoly
  302. ▐                        // but not to fonts filling.
  303. ▐     paint->set_zoom(0.5, 0.8);             // Set picture deformation
  304. ▐
  305. ▐     for(int i = 0; i < 360; i += 15)       // BGI fonts output with rotation
  306. ▐     {
  307. ▐     paint->rotate(loc(400, 200), i);
  308. ▐     paint->outtextxy(10, 200, "Hello, World !");
  309. ▐     }
  310. ▐
  311. ▐     cleardevice();
  312. ▐
  313. ▐     for(int i1 = 0; i1 < 360; i1 += 15)    // Primitives output with rotation
  314. ▐     {
  315. ▐     paint->rotate(loc(400, 200), i1);
  316. ▐     paint->roundrect(300, 100, 400, 200, 20);
  317. ▐     int poly[10] = {100, 100, 200, 100, 200, 200, 100, 200, 100, 100};
  318. ▐     paint->drawpoly(5, poly);
  319. ▐     }
  320. ▐
  321. ▐     cleardevice();
  322. ▐     paint->set_stack(ON);                  // Switch complex rotations ON
  323. ▐     for(i = 0; i < 360; i += 30)           // First call rotate image to 30,
  324. ▐     {                                  // second to 60 and so on.
  325. ▐     paint->rotate(loc(400, 200), 30);
  326. ▐     paint->outtextxy(10, 200, "Hello, World !");
  327. ▐     }
  328. ▐
  329. ▐     paint->set_stack(OFF);
  330. ▐     for(int j = 0; j < 360; j += 15)
  331. ▐     {
  332. ▐     paint->rotate(loc(400, 200), j);            // Ellipse rotations
  333. ▐     paint->ellipse(200, 200, 0, 360, 30, 20);
  334. ▐     paint->ellipse(300, 200, 50, 120, 30, 20);
  335. ▐     }
  336. ▐
  337. ▐     delete paint;
  338. ▐     closegraph();
  339. ▐     }
  340.